home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / asm / lass.com / LASS-1.MAN < prev    next >
Encoding:
Text File  |  1989-09-08  |  48.7 KB  |  1,083 lines

  1. ..All lines beginning with two periods are ignored by PC-Write
  2. ..If you have a different word processor you need to remove these lines.
  3. ..Also note three coded lines just before Chapter I and at the beginning
  4. ..of Lass-2.man. They are directionsto PC-Write to number the pages,
  5. ..starting with page 1, and placing the numbers in the middle of a footer
  6. ..line leaving 1 blank between text and footer.
  7. ..If your word processor is not PC-Write, you may need to change them.
  8. ..Similaraly, the end of each page is marked with ALT 12 (0C), or " "
  9. ..My apologies, but I know no way of offering you a neat printout
  10. ..without these marks.
  11.  
  12.  
  13.  
  14.  
  15.  
  16.                               LASS 
  17.  
  18.                       THE LITTLE ASSEMBLER 
  19.                           for 8088 code
  20.  
  21.  
  22.  
  23.                       by Dorothy R. Mooney
  24.                      (Copyright 1986, 1989)
  25.  
  26.  
  27.  
  28.  
  29.                         Table of Contents
  30.  
  31.     I      Begin with Backup   . . . . . . . . . . . . . .  1
  32.            and general instructions for using Lass
  33.  
  34.     II     Linking       . . . . . . . . . . . . . . . . .  5 
  35.  
  36.     III    End of File   . . . . . . . . . . . . . . . . .  6 
  37.  
  38.     IV     Source Code Syntax  . . . . . . . . . . . . . .  8
  39.  
  40.     V      Mnemonic Table  . . . . . . . . . . . . . . . . 13
  41.  
  42.     VI     Pseudo Ops    . . . . . . . . . . . . . . . . . 21
  43.  
  44.     VII    Error Messages  . . . . . . . . . . . . . . . . 23
  45.   
  46.     VIII   Basic Linking   . . . . . . . . . . . . . . . . 26
  47.   
  48. .N:1 
  49. .F:
  50. .F:...Page $$$...
  51.  
  52.                             Chapter I   
  53.                         Begin with Backup
  54.  
  55.      Before printing and reading this document,  you should have 
  56. backed  up  the  Lass disk.  If not,  do it now.  Reordering and 
  57. waiting to replace a tromped on disk when you have  your  source 
  58. code all ready to assemble will not make your week, believe me !  
  59. Files are:
  60.  
  61.      Lass.txt         a short note to get you started
  62.      Lass-1.man       the manual of instructions
  63.      Lass-2.man
  64.      LASS.com         the Little Assembler
  65.      L-Ruler.asm      a PC_Write file
  66.  
  67.      That ruler file is one I use for writing source  code  with 
  68. PC-Write.  If you have some other word processor it will  be  of 
  69. no use to you: ignore it.  To use it with PC-Write you need only 
  70. rename  the file Ruler.asm.  A quick look with PC-Write's editor 
  71. will show you what it will do.
  72.  
  73.      Lass translates your 8088 source code into machine lanuage, 
  74. creating a .COM program.  Such a program can be any size  up  to 
  75. 65,535 bytes in length,  or 64K,  the size of one  segment.  The 
  76. source code for a long program may burst the limits of your word 
  77. processor,  but  you  can  write  and file it into more than one 
  78. source file,  and Lass will will  be  able  to  link  the  parts 
  79. together into one program.  
  80.  
  81.      Once  you  have written your source code all you need to do 
  82. to run Lass, assuming Lass.com is on the disk in drive A,  is to 
  83. enter drive A and type: 
  84.  
  85.    A>   lass         and press the Enter key.
  86.  
  87.      When Lass has been loaded  into  memory,  the  screen  will 
  88. fill with text.  Follow the prompts on the screen.  When you are 
  89. asked for a drive, enter the drive letter.  Any letter from A to 
  90. E will be accepted.  Once all questions are answered,  Lass gets 
  91. to work.  When assembly is complete a message will appear on the 
  92. screen,  perhaps "There were 5 assembly errors".  Since an error 
  93. may be counted during each pass,  most of them will  be  counted 
  94. twice.   When  the  message  "There  were  No  assembly  errors" 
  95. appears, you are ready to try running the program.  
  96.  
  97.      Since  Lass loads completely into memory,  if you keep Lass 
  98. on  a  disk  by  itself  you  can remove it as soon as the first 
  99. message appears on the screen,  and replace it with  either  the 
  100. disk holding your source code, or a separate disk to receive the 
  101. object (.COM) file.  As the program runs you will be asked which 
  102. drive holds the source file(s) and which will receive the object 
  103. file,  so  they may be on separate disks if you wish.  Note that 
  104. once assembly has started,  the object (.COM) file must  NOT  be 
  105. moved.  If you are using Llinker.asm,  it  too  must stay in one 
  106. place,  so  Lass assumes that the two immovables are on the same 
  107. disk in the same drive.  If this is not also  the  source  disk, 
  108.  
  109. transfer  Llinker.asm  to  the  new  object disk before entering 
  110. LASS.com.   Llinker.asm is discussed in Chapter II.
  111.  
  112.      If you have as much as 128K in  your  computer  you  should 
  113. have  no  difficulty  with  LASS.com.  If  Lass  hangs up during 
  114. assembly you may have too many labels.  See the discussion under 
  115. LABELS in Chapter IV.  
  116.  
  117.      If  you  have just one drive your problem will be space for 
  118. your source files.  You can still use a  Llinker.asm  file,  but 
  119. all the source files must be on that one disk,  along with space 
  120. for the new object file .COM.  If you answered "y" when asked if 
  121. you  want  a listing file,  more than half the disk must be free 
  122. since the .LST file will be longer than the source file(s). (The 
  123. listing file lists each line  of  source  code  along  with  the 
  124. object code for the line.  Useful in debugging a long program.) 
  125.  
  126.      When you are asked for the name of your source file, if you 
  127. have  just  one  source code file,  enter the filename,  with or 
  128. without an extension. You may use any extension you wish, but if 
  129. you enter none, the extension .ASM will be assumed.  If there is 
  130. more  than one source file,  you must use a Llinker file.  Since 
  131. LLINKER.ASM is the default,  you need only press Enter to choose 
  132. this  option.  Lass  will  look for the Llinker file on the disk 
  133. you specify for the object file.  
  134.  
  135.      For the object file,  the default is your source  filename, 
  136. or the first name in the Llinker file,  with the extension .COM.  
  137. If this is what you want, merely press Enter.  If not, enter the 
  138. name you do want,  with or without extension.  If you enter just 
  139. a filename, the extension .COM will be added, since DOS will not 
  140. run your new program without it.  
  141.  
  142.      You will also be asked if you want listings. If you ask for 
  143. a Pass One listing,  the decimal line number and source code for 
  144. each line will be displayed on the screen.  This slows down  the 
  145. assembly,  and Error messages also show the line number,  so you 
  146. can do without this listing.  However,  if an error  causes  the 
  147. computer to hang up during assembly,  use the screen listings on 
  148. your next try to help you find the error.  
  149.  
  150.      For  a  Pass  Two listing each code line is preceded by the 
  151. hexadecimal offset address of the line and up to  six  bytes  of 
  152. the object code for the line.  The listing may be printed,  sent 
  153. to the screen,  or filed in anĀ·.LST file on disk.  If you choose 
  154. the Print option it is wise to do a trial assembly first without 
  155. listing  to make sure that there are no assembly errors to cause 
  156. you  to  do  it  all  over  again.  Printing takes time.  If you 
  157. choose to have the listing sent  to  a  disk  file,  check  disk 
  158. space:  the .LST file will go onto the same disk with  the  .COM 
  159. (object) file and it will take up to half again as much space as 
  160. the source file(s).  There will be just one (long) file with the 
  161. same name as the .COM file, but with the extension .LST.  
  162.  
  163.      You will also be asked if you wish a Label Cross  Reference 
  164. file,  to  be  written  to disk.  Every label is listed with its 
  165. address and the address of up to 10 locations  where  the  label 
  166.  
  167. was used in an operand.  There is a pause before filing to allow 
  168. you to change to a new disk,  so you need not cross your fingers 
  169. and hope it will not overflow.  The file will be given the  same 
  170. name as the object file, but with the extension .REF.  
  171.  
  172.      Lass makes two passes through the source code.  During Pass 
  173. One,  a count is made of the object  code  bytes  that  will  be 
  174. needed  and  a  Label  Table  is created.  This table lists each 
  175. label in your source code and uses the object code byte count as 
  176. the address where the  label  is  to  be  found.  Since  a  .COM 
  177. program may be loaded by DOS anywhere in memory, the location of 
  178. a  particular  label  may be found only in relation to the first 
  179. code byte.  That is,  if the byte count is 297h when  the  label 
  180. Clear_Screen is found, 297h is the offset address of that label.  
  181. Or,  more  simply,  the  offset.  (See  EQU in the chapter on op 
  182. mnemonics for the handling of those labels.) 
  183.  
  184.      The second pass generates the code  and  files  it  onto  a 
  185. disk, using the offset addresses in the label table to translate 
  186. each  label used in an operand into a number. 
  187.  
  188.      If errors are found during assembly,  a message is shown on 
  189. the screen.  For most errors you can make a note,  continue with 
  190. the  assembly  and  correct  the  source  code  after  you  have 
  191. collected  all  the  errors.  Then  try again.  When you get the 
  192. message "No assembly errors" you have a  perfect  .COM  program.  
  193. Perfect, that is,  so far as syntax is concerned.  If you want a 
  194. listing now is the time to call for it,  making a final assembly 
  195. run when you know time and paper will not be wasted.  
  196.  
  197.                            Chapter  II
  198.                              Linking
  199.  
  200.      When there is more than one source file,  Lass  needs  some 
  201. way  of  finding  them  all,  and in the right order.  A special 
  202. file,  LLINKER.ASM is used.  It is nothing more then a  list  of 
  203. all  your  source  files.  If you have source code for more than 
  204. one program on  your  disk  and  want  to  keep  more  than  one 
  205. llinker file, rename the one you are not using, perhaps LL-1.
  206.  
  207.      Using your word processor, make a list of all source files, 
  208. in the order you wish to have them assembled.  Any mix of  upper 
  209. and  lower case letters may be used.  There must be nothing else 
  210. in the file,  and the file must end with an  end  of  file  mark 
  211. (EOF)  like  any other source file.  (See the next chapter for a 
  212. discussion of the end of file mark.)  For example: 
  213.  
  214. DATA.asm+
  215. CODE.asm+
  216. Code2.asm+
  217. *Insert disk with MoreCode & LastFile+
  218. MoreCode.asm+
  219. LASTFILE.asm+
  220. (EOF)
  221.  
  222.      Note that each filename is flush left,  each filename is on 
  223. a  separate  line  and  ends with a plus sign,  and there are no 
  224. comments.  The  asterisk  at the start of a line signals to Lass 
  225. that there is to be a pause.  The line itself is the message you 
  226. wish to have displayed on the screen.  The program will wait for 
  227. you  to  change  the source disk and press enter.  Note that the 
  228. message line, too, ands with a plus sign.  
  229.  
  230.                            Chapter III
  231.                           End  of  File
  232.  
  233.      Lass does not have sense enough to stop if there is no  end 
  234. of  file  mark  on  your  source or LLinker file,  but will keep 
  235. trying to parse whatever else is on  the  disk.  Disaster!  This 
  236. important  mark is simply the hexadecimal number 1A,  or decimal 
  237. 26.  It will appear on the  screen  as  a  small,  right  facing 
  238. arrow.  (This  is not the same arrow produced by the escape key, 
  239. which is left facing.) 
  240.  
  241.      Using your word processor, check the end of the file. If no 
  242. little right facing arrow appears, try adding it.  Hold down the 
  243. alternate key (Alt) and press 2 and then 6 on  the  number  pad.  
  244. When  you  release  the Alt key the arrow should appear.  If you 
  245. have written your code with Edlin, the marker will be there.  If 
  246. you load your file into Edlin and then enter 'e', Edlin will add 
  247. the marker if it is not already  there.  Note  that  Edlin  also 
  248. creates  a .BAK file which is as long as the original,  so watch 
  249. your disk space.  
  250.  
  251.      If there seems to be no other way out,  write a short  file 
  252. (one  word will do) with Edlin and End (press 'e').  Then append 
  253. it to the end of your code file,  using your word  processor  or 
  254. the DOS copy command.  (See your DOS manual.) Of course,  if you 
  255. write this file before you write your source code,  you can load 
  256. it into your word processor, rename it, and then write the code.  
  257. Be careful not to erase the marker.  
  258.  
  259.                             Chapter IV
  260.                         Source Code Syntax
  261.  
  262.      To write your source code,  use a word processor,  or,  for 
  263. short programs,  Edlin.  If you have not read the  End  of  File 
  264. chapter, do so now.  It is also important to know that Lass will 
  265. recognize only ascii text,  tabs,  carriage return and line feed 
  266. (set by the Enter key) and that EOF mark.  A period as the first 
  267. character of a line will cause the whole line to be ignored.  
  268.  
  269.      Each operation,  consisting of an op code and any  operands 
  270. it  needs,  must  be on a separate line.  No line of code may be 
  271. more than 78 characters long (plus  carriage  return),  and  the 
  272. first character in the line must be a space or tab, a semicolon, 
  273. or else the first letter of a label.  If you use  PC-Write,  you 
  274. may  use  comment  lines  starting  with  ".."  (two periods) or 
  275. printer commands  starting  with  ".",  one  period,  with  full 
  276. confidence that Lass will ignore them.  The order of 
  277.  
  278. LABEL    OP    OPERAND, OPERAND   
  279.  
  280. must be maintained, and the parts must be separated by spaces or 
  281. tabs  or,  in the case of the two operands,  by a comma.  Except 
  282. for the label,  the column position doesn't matter.  A semicolon 
  283. (;) or a colon (:) after a label will cause the rest of the line 
  284. to be ignored.  
  285.  
  286.      Code may be written in any combination of upper  and  lower 
  287. case:  Mov, MOV, and moV will all be accepted.  However, Lass is 
  288. quite rigid and unforgiving of spelling errors.  But then, so is 
  289. your eye.  You are used to seeing a word all of a piece, without 
  290. sp ace s int he mid dleofit.  You are smart enough to make sense 
  291. out of that sentence,  but Lass cannot make sense out of M OV or 
  292. [ bx + 03].  For operands,  a comma is used as a separator,  and 
  293. must fit tightly against the operand it follows,  but a space or 
  294. so  before  the  next operand can be assimilated.  For instance, 
  295. the following are ok: 
  296.  
  297.             mov     ax,3
  298.             mov     ax,    16d
  299.             movB    [bx], Labelnn
  300. but NOT:
  301.             add     ax3  
  302.             sub     ax 15
  303.             mov     ax ,Anything
  304.  
  305.      Since the program is limited to one  segment,  such  pseudo 
  306. ops as "ASSUME" or "PROC",  used in creating .EXE files, are not 
  307. needed and will be ignored if they are found.  
  308.  
  309. LABELS
  310. ~~~~~~
  311.      LASS.com uses a full segment (64K) in memory to hold up  to 
  312. 2048 (decimal) labels for a program.  In case this is not enough 
  313. for  your  source  code,  check  out  the  $+  alternative under 
  314. conditional jumps (directly after IRET below).  
  315.  
  316.      The first character of a label must be the first  character 
  317. on  the  line.  If  a  space manages to creep in first,  it will 
  318. cause Lass to try to make an op code of the label, to everyone's 
  319. confusion.  Labels may be as long as 32 characters, but only the 
  320. first 10 characters will be used by Lass.  Upper case and  lower 
  321. case letters will be treated as equals, so that Little_Assembler 
  322. and LITTLE_ASSYRIAN would be taken to be the same label.  
  323.  
  324.      The  first  character  following a label must be a space or 
  325. tab or a colon (:),  or a carriage return.  The  colon  will  be 
  326. taken  as  the  end  of the line,  a space or tab will cause the 
  327. assembler to continue searching for an op mnemonic.  
  328.  
  329.      The first character of a label must be a letter, or one of 
  330. the characters between Z and a in the ascii listing.
  331.  
  332.                 \ ^ _ `
  333.  
  334. Within a label these additional characters will be accepted: 
  335.  
  336.                 < = > ? @ ! " # % & ( ) * . /
  337.  
  338.      If characters above lower case z (7Bh) are used,  they will 
  339. be changed along with lower case  letters  by  subtracting  20h.  
  340. The line (|) or tilde (~) will become (\) or (^),  but the curly 
  341. brackets { } will become square brackets [ ] and should never be 
  342. used.  Of  course  other  characters  which are used in operands 
  343. should not be used, such as,  + - $ ' [].  Lass will accept them 
  344. with  no warning in the label column,  but will try to translate 
  345. them  for  their  special meanings if they appear in an operand.  
  346. Note that a period  in  the  first  column  will  be  cheerfully 
  347. accepted  but the whole line will be ignored.  See the beginning 
  348. of this chapter.  
  349.  
  350. Possible syntax:
  351.  
  352. Second_Call  equ  NEW#@_CALL
  353. New#@_Call:
  354.         mov     AX,0
  355. Re/Call Mov     Cx,19h
  356. \After_Thought
  357.         Inc     CX
  358.  
  359. Not permitted:
  360.  
  361. /No_Code: mov    cx,0        ;"/" is forbidden in 1st position.   
  362.                              ;The colon ends the line and
  363.                              ;all the code would be lost.
  364. Trouble+here:                ;the "+" will cause confusion when
  365.                              ;CALL  Trouble+here  is found.
  366.  
  367.      There is one use of a label which will cause  trouble,  and 
  368. Lass  has  no way of wriggling out.  If a label is set by an EQU 
  369. statement to a value below 128 (80 hex) and  then  used  as  the 
  370. displacement within a pointer, the EQU statement absolutely must 
  371. come  at  the  head of the program.  If Lass finds the operation 
  372. statement first during the first pass of the assembly,  she will 
  373. not  know  the value so will assume a word.  When the byte value 
  374. is substituted on the second pass, the byte count will be thrown 
  375. off - an error from which there is no return.  For instance: 
  376.  
  377.         mov     al,[si+Name]    ;NOT YET  - Name unknown
  378.  
  379. Name    equ     5               ;place all EQU statements ahead
  380. Address equ     10              ;of any code
  381.   ,..
  382.     ,..
  383.         mov     al,[si+Name]    ;ok, Lass now has the value
  384.  
  385. OP Mnemonics
  386. ~~~~~~~~~~~~
  387.      Most  of  the  codes  in  your assembly language primer are 
  388. accepted  by  Lass,  but  since  all your code must be contained 
  389. within one segment for a .COM program,  far jumps  or  calls  to 
  390. another  segment  will  produce an error message.  4 letter jump 
  391. codes,  such as JNAE,  will cause  confusion,  producing  errors 
  392. which will not be found by the assembler.  (See Jumps) 
  393.  
  394.      The OP mnemonic must be preceded by  a  space  or  tab  and 
  395. followed  by  another space or tab.  If there is no operand,  an 
  396. immediate carriage return or semicolon is accepted.  
  397.  
  398. OPERANDS
  399. ~~~~~~~~
  400.      The first operand must be preceded by a space or tab and be 
  401. followed immediately by a comma.  If there is  a  space  between 
  402. the operand and the comma, the comma will be ignored and the end 
  403. of the line assumed.  There may be a space (or spaces) following 
  404. the  comma.  The  second  operand  may be followed by a space or 
  405. tab, a semicolon, or a carriage return.  
  406.  
  407.      When a pointer operand needs to be identified as a byte  or 
  408. word  pointer,  Lass  looks  for  a  B  or  W  as part of the op 
  409. menemonic.  For instance: 
  410.  
  411.         movB   [DI],0     or     INCW    [varbl_1]
  412.  
  413.      All the register pointers are accepted, up to and including 
  414. such monsters as [BX+DI+LongLabel].  If you are  counting  bytes 
  415. for  short jumps you need to be aware that [BP] will be accepted 
  416. and translated to [BP+00], adding one more byte to what you have 
  417. written.  There must be no spaces within the  []  and  the whole 
  418. operand must be within the two brackets.  -5[BX] instead of [BX-
  419. 5]  will result in an error.  Acceptable label addresses include 
  420. [Kentucky+36h] or [BX+Kentucky] but  not  [BX+Kentucky+01].  And 
  421. note that [SI-BX] is not acceptable:  registers must  be  added.  
  422. Of course,  you can get around this  restriction  by  putting  a 
  423. negative number into BX.  
  424.  
  425.      Lass treats numbers and numbers translated from  labels  in 
  426. exactly the same way: 
  427.  
  428. For numbers:
  429.  
  430.       mov  ax,3000h             ;an immediate number into AX
  431.       mov  ax,[3000h]           ;AX takes the number stored 
  432.                                 ;at memory location 3000h
  433. Similarly:
  434.  
  435.       mov  si,Pennies           ;SI takes the immediate number
  436.                                 ;represented by "Pennies"
  437.       mov  ax,[Pennies]         ;AX takes a number from the 
  438.                                 ;memory location "Pennies"
  439.       mov  cx,[si]              ;and now CX = AX
  440.  
  441. NUMBERS 
  442. ~~~~~~~ 
  443.      Lass  does  not speak in octaves nor in binary,  but either 
  444. decimal or hexadecimal numbers will be accepted. In either case, 
  445. the number  must  start  with  a  decimal  digit,  so  FFh,  for 
  446. instance,  must  be  written  as 0FFh.  A decimal number will be 
  447. accepted with or without a 'D' at the  end,  but  a  hexidecimal 
  448. number must usually terminate with 'H'. 0F would be processed as 
  449. hexidecimal,  but  0D  would  be  taken for a decimal 0.  Single 
  450. ascii characters are accepted, but no binary numbers, please.  
  451.  
  452. acceptable:
  453.         Mov     ax,65           ;decimal
  454.         incB    [bx+15d]        ;decimal
  455.         add     cx,41h          ;hexadecimal
  456.         sub     al,'0'          ;ascii
  457.         and     al,03           ;instead of binary 0011
  458. NOT acceptable:
  459.         and     al,1D           ;D = decimal
  460.         mov     cl,FFh          ;will be mistaken for a label
  461.         mov     ax,'BA'         ;2 ascii characters
  462.         and     al,0011b        ;Lass reads 11B hexadecimal
  463.  
  464.      Number length is limited by the capacity of a byte or word.  
  465. With a short jump or a 1 byte displacement,  which can be either 
  466. positive or negative,  the number must be within  the  range  of 
  467. -128 to +127 decimal (80h to 0 to 7Fh).  However,  an  immediate 
  468. number  is  assumed  to  be  positive and may be as large as 255 
  469. decimal (0FFh). A word displacement, such as [BX-645], may range 
  470. from -32,768 to +32,767 (0FFFFh to 7FFFh). An immediate word may 
  471. hold a number as large as 65,535 (0FFFFh).  
  472.  
  473.      If  you  have  not met hexadecimal numbers before,  0FFh as 
  474. either -128 or 255 may seem like a bit  of  slick  dealing.  The 
  475. difference  comes because a number that has no sign may use each 
  476. of the 8 bits in the byte, but for a signed number, the leftmost 
  477. bit is used to signal positive (0) or negative (1), leaving just 
  478. seven bits for the number itself.  
  479.  
  480. COMMENTS
  481. ~~~~~~~~
  482.      A  comment  may start at any place on the line,  and should 
  483. start with a semicolon (;). Everything beyond the semicolon will 
  484. be ignored by the assembler.  If a comment continues on a second 
  485. line, it must be preceded by another semicolon.  As you get used 
  486. to using Lass you will find that  often  the  semicolon  is  not 
  487. necessary.  The  assembler  knows how many operands belong to an 
  488. op code and will ignore anything beyond them  on  the  line.  Do 
  489. not  count  on  this  blindly - RET,  for instance,  may have no 
  490. operand or a number,  so Lass can't know to end the line without 
  491. a marker.  
  492.  
  493.      Do not use ' in a comment.  The reverse quote,  (`) may  be 
  494. used,  or the double quote ("), but the normal single quote will 
  495. cause the remaining portion of a comment to be listed  in  upper 
  496. case letters.  
  497.  
  498.      Since many print programs take a period to signal a command 
  499. line,  Lass  will  treat  any line which starts with a period as 
  500. non-existent.  It  will not even be counted.  The period must be 
  501. in the first column, though,  or it will be taken for an unknown 
  502. operand.  
  503.  
  504. ADDRESSING MODES
  505. ~~~~~~~~~~~~~~~~
  506.      These   are  simply  terms  identifying  the  various  ways 
  507. registers, pointers and displacements, and immediate numbers may 
  508. be combined to carry out the code operations.  The 8088 language 
  509. permits any of the following examples with most of the op codes.  
  510. Where there are exceptions they are noted in the mnemonic table.  
  511. Segment  registers  are  special:  see  the  MOV,  PUSH  or  POP 
  512. mnemonics.  An immediate number is one which is used  by  itself 
  513. as the second operand.  
  514.  
  515. Register, Register:     mov     ax,bx
  516.                         test    cl,bh
  517.                         mov     ax,es
  518. Register, Immediate:    mov     ax,0
  519.                         mov     si,Any_Old_Label
  520.                         add     ch,23
  521. Pointer, Register or
  522. Register, Pointer:      mov     al,[si]
  523.                         add     [bx+si+03],bh
  524.                         cmp     [BX+Table_1],cl
  525. Pointer, Immediate:     movW    [di],0D0Ah
  526.                         cmpB    [bx],17
  527.                         xorB    [bx+Table_1],7Fh
  528.  
  529.      Note that where a pointer is combined with a register, Lass 
  530. knows  whether the pointer is pointing to a byte or a word,  but 
  531. when there  is  only  an  immediate  number,  even  when  it  is 
  532. obviously too big for a byte, the op code mnemonic must have a B 
  533. or a W tacked on to help the assembler.  
  534.  
  535.      There  is no pointer to pointer addressing mode in the 8088 
  536. language.  
  537.  
  538.                             Chapter V
  539.                           Mnemonic Table
  540.  
  541.      Unless otherwise noted, an op code takes two operands, uses 
  542. any of the addressing modes,  and affects the flags noted in the 
  543. right  column.  If  no  flag  is  marked,  none is affected.  To 
  544. complement means to set a bit to 1 if 0 or to clear a bit  to  0 
  545. if it is 1.  When the code LAHF or SAHF is used, it is the right 
  546. byte of the flags register that is loaded into  or  stored  from 
  547. AH. Bits that are unaccounted for in the list are simply unused.  
  548.  
  549.                 left byte       right byte of flags register
  550. Flags are:   O  overflow     S  sign
  551.              D  direction    Z  zero
  552.              I  interrupt    A  auxiliary carry
  553.              T  trap         P  parity
  554.                              C  carry
  555.  
  556. The following symbols are used to show how flags are affected:
  557.  
  558. x flag is set according to the result of the operation. 
  559. 0 flag is cleared, whatever the result. 
  560. 1 flag is set to 1, whatever the result. 
  561. . (period) the flag may be affected, but unpredictably. 
  562.  
  563.                             ---------
  564.                                                O D I T S Z A P C
  565. AAA     ascii adjust for addition              .       . . x . x
  566. AAD     ascii adjust for division              .       x x . x .
  567. AAM     ascii adjust for multiplication        .       x x . x .
  568. AAS     ascii adjust for subtraction           .       . . x . x
  569.  
  570. ADC     add  with carry.  Adds  the  second    x       x x x x x
  571.         operand to the first operand,  then 
  572.         adds the 0 or 1 from the carry flag.  
  573.  
  574. ADD     adds as above, but ignores the carry   x       x x x x x
  575.         flag
  576.  
  577. AND     compares the bits  of  two  operands.  0       x x . x 0
  578.         If a bit in the first operand is set 
  579.         to 1, AND the same bit in the second 
  580.         operand is set to 1, that bit in the 
  581.         first  operand  will remain  1;  any 
  582.         other bits will be set to 0. That is: 
  583.  
  584.         mov     ax,64h          ;0110 0100
  585.         and     ax,0Fh          ;0000 1111 
  586.                                 ;0000 0100  04 now in AX
  587.  
  588. CALL takes a 2 byte displacement number.  See JA,  etc.,  for an 
  589.         explanation of how this number is used.  It  may  be  in 
  590.         the  form  of  a  label,  held in a double register,  or 
  591.         pointed to by a word pointer.  An immediate  number  may 
  592.         also  be  used,  if  you  know where the routine you are 
  593.         calling will be assembled.  This is unlikely,  but could 
  594.         be  true  if  you have located it with an ORG statement.  
  595.         The displacement syntax $+/-  may  not  be  used.  Since 
  596.  
  597.         only one segment may be addressed, FAR CALLs will result 
  598.         in  an  error message.  Remember that the offset address 
  599.         of the operation following the CALL is pushed  onto  the 
  600.         stack  when the call is made,  and must be available for 
  601.         the RETurn.  Keep careful count of PUSHes and POPs.  Any 
  602.         of the following addressing modes is acceptable: 
  603.  
  604.         call    Old_Hat         ;label
  605.         call    BX              ;double register
  606.         call    [BX+DI+03]      ;can only be word pointer, so
  607.                                 ;callW is not necessary
  608.  
  609. The following 6 op codes take no operand; only the flag referred 
  610. to by the code, if any, is affected.  
  611.  
  612. CBW     Convert byte to word. Byte in question is the AL
  613.         register; AH is set to 0, or FF if bit 7 is set.
  614.         For this code, 8088 assumes that any number 
  615.         greater than 127 (7Fh) is negative.
  616. CLC     Clear carry flag         
  617. CLD     Clear direction flag
  618. CLI     Clear interrupt flag
  619. CMC     Complement carry flag
  620. CWD     Convert word to double word. Word in question is in
  621.         the AX register; DX is set to 0, or FFFF if word is 
  622.         negative, that is, greater than 7FFFh
  623.  
  624.                                                O D I T S Z A P C
  625. CMP     Compares two operands  by pretending   x       x x x x x
  626.         to  subtract  the  second  from  the 
  627.         first,  but  without changing either 
  628.         operand.    Action  may   be   taken 
  629.         according to the status of the flags.  
  630.         See the jumps, and compare with TEST.  
  631.  
  632. CMPS    Compares two strings as  for CMP, by   x       x x x x x
  633.         subtracting    the   source  string, 
  634.         pointed  to  by  DS:SI  (segment and 
  635.         offset) from the destination string pointed to by ES:DI.  
  636.         Length  of string must be in the CX register.  SI and DI 
  637.         are incremented if the direction flag is clear  (UP), or 
  638.         decremented  if it is set (DN):  once for CMPSB or twice 
  639.         for CMPSW.  
  640.  
  641. The next two codes take no operand.
  642.                                                O D I T S Z A P C
  643. DAA     Decimal adjust for addition            x       x x x x x
  644. DAS     Decimal adjust for subtraction         .       x x x x x
  645.  
  646. DEC     Decrement by 1. Takes 1 operand.       x       x x x x
  647.  
  648. DIV     Divide  AL  by a  single register or   .       . . . . .
  649.         byte  pointer, leaving the remainder  
  650.         in AH, or AX by a double register or 
  651.         word pointer,  leaving the remainder in DX.  AL or AX is 
  652.         implied,  only the register or pointer is needed.  AH or 
  653.         DX must hold 0 before division.  
  654.  
  655. DS:     segment registers.  Each  should be  on a line by itself, 
  656. ES:     preceding the op code which it affects.
  657.         That is, instead of
  658.  
  659.                 MOV  ES:[DI],AX
  660.  
  661.         write on two lines
  662.  
  663.                 ES:
  664.                 MOV  [DI],AX
  665.  
  666. HLT     Halt. No operand. Waits for an interrupt, such as from a 
  667.         printer.  Will merely hang up the computer if you try to 
  668.         use it to set break points for debugging.  
  669.  
  670. For  the  next two op codes,  the numbers are 
  671. read as signed numbers.  
  672.                                                O D I T S Z A P C
  673. IDIV    Integer (signed number) division. As   .       . . . . .
  674.         for DIV.
  675. IMUL    Integer (signed number) multiplicat-   x       . . . . x
  676.         ion.  Otherwise as for MUL
  677.  
  678. IN      Input  byte  or  word  into AL or AX 
  679.         from one of 256 possible ports. Port 
  680.         number may be an immediate number or 
  681.         held in DX.  
  682.  
  683. INC     Increment by 1. Takes one operand.     x       x x x x
  684.  
  685. INT     A  call to  the first  "page" of DOS       0 0
  686.         Uses a 1  byte number  for  address.  
  687.         INT 21h is the most used.  
  688. INTO    Interrupt if overflow flag is set to       0 0
  689.         1.  (Calls INT 4)
  690. IRET    Interrupt return. Restores all flags 
  691.         and POPs the CS register as well  as 
  692.         IP.  See RET.  
  693.  
  694. None  of the following conditional JUMP codes affects any of the 
  695. flags.  They each take one operand,  a one byte immediate signed 
  696. number.  This  number  is  the difference (displacement) between 
  697. the offset address of the code following the jump and the offset 
  698. address of the  destination.  It  is  usually  provided  in  the 
  699. source code by a label: 
  700.  
  701.         JC      Next_Lap
  702.  
  703. Since the jump may be made in either direction,  the number  may 
  704. be either plus or minus and the limits are -128 and 127 (FFh and 
  705. 7Fh).  See  the  error  message "Jump too far" for how to handle 
  706. this error during assembly.  Also note the mnemonics marked with 
  707. an asterisk in the conditional  jump  table.  They  may  not  be 
  708. used.  However, there is an alternative listed for each one.  
  709.  
  710. You may also use the dollar symbol "$" to order Lass to  use  an 
  711. immediate number as the displacement byte.  In order to use this 
  712. convention successfully you must know the  number  of  bytes  in 
  713. each  operation  that  you jump.  Don't worry about making sense 
  714. out of the following code, just note the way $+/- is used.  
  715.  
  716.         cmp     ax,dx    <----.   2 bytes ------.
  717.         ja      $+6    =----. ;   2 bytes        \
  718.         jz      $+3    =--. ; ;   2 bytes -.      \
  719.         mov     ax,0      ; ; ;   3 bytes   } 6    } 15
  720.         ret            <--' ; ;   1 byte  -'      /
  721.         mov     ax,63h   <--' ;   3 bytes        / 
  722.         loop    $-15d      =--'   2 bytes ------'
  723.  
  724.  
  725. op      jump if:  
  726. ~~~~~~~~~~~~~~~
  727. JA      destination operand is above source operand
  728. JAE                            above or equal
  729. JB      destination operand is below source operand
  730. JBE                            below or equal
  731. JC      carry flag is set (to 1).  Similar to JB.
  732. JCXZ    CX is 0.  (Compare to LOOP.)
  733. JE      operands are equal. Same as JZ.
  734. JG      dest'n operand is greater than source operand
  735. JGE                       greater than or equal. Same as JNL
  736. JL      destination operand is less than source operand
  737. JLE                       less than or equal. Same as JNG.
  738. JNA     destination operand is not above source operand
  739. JNAE*   will be mistaken for JNA: use JB
  740. JNB     destination operand is not below source operand
  741. JNBE*   will be mistaken for JNB: use JA
  742. JNC     carry flag is not set (to 1). Same as JNB
  743. JNE     destination operand is not equal to source operand
  744. JNG     destination operand is not greater than source operand
  745. JNGE*   will be mistaken for JNG: use JL
  746. JNL     destination operand is not less than source operand
  747. JNLE*   will be mistaken for JNL: use JG
  748. JNO     overflow flag is not set (to 1).
  749. JNP     parity is odd. Same as JPO.
  750. JNS     sign flag is not set (to 1). (positive result)
  751. JNZ     zero flag is not set (but is 0).
  752. JO      overflow flag is set (to 1).
  753. JP      parity is even. Same as JPE.
  754. JPE     parity is even.
  755. JPO     parity is odd.
  756. JS      sign flag is set (to 1). (negative result)
  757. JZ      operands are equal. (Zero flag is set to 1) Same as JE.
  758.  
  759. The next two jumps take no conditions for action,  but otherwise 
  760. act  in the same way as the conditional jumps.  JMP uses 2 bytes 
  761. for the displacement and JMPS uses just 1 byte.  
  762.  
  763. JMP     see CALL
  764. JMPS    Short jump.  May  be  used  if  displacement is a 1 byte 
  765.         number.  May also be used with  $+/-.
  766.  
  767. LAHF    load  AH register from  flags register.  No operand. The
  768.         right  flag  byte  with    S  Z  _ A _ P _ C   is moved. 
  769.         The unnamed bits are not in use.  See SAHF.  
  770.  
  771. LDS     Sets up  two  registers,  usually  to point into another 
  772.         segment.  The register,  pointer mode is  the  only  one 
  773.         permitted. For example, LDS  DI,[BX+SI]  loads registers 
  774.         DS  and  DI  from  the  two  words pointed to by the 2nd 
  775.         operand.  DI is loaded from the first two bytes, DS from 
  776.         the last two.  
  777.  
  778. LEA     load effective address
  779. LES     As for LDS, using the ES segment register.  If 0007 were 
  780.         stored at Video_Addr and B000 in the next word then  LES 
  781.         AX,[Video_Addr]  would point  ES  to the black and white 
  782.         screen memory segment and set 0700 into AX.  
  783.  
  784. LOCK    lock bus. No operand.
  785.  
  786. LODS    loads AL or AX with string pointed to by  DS:SI (segment 
  787.         and  offset).  No operands, but  B  or  W  must be added 
  788.         (LODSB or LODSW).  SI is incremented if  direction  flag 
  789.         is clear (UP) or decremented if flag is set (DN).  
  790.  
  791. One operand, the displacement number, for LOOP operations.  Uses 
  792. the same rules as conditional jumps, including use of $+/-.  
  793.  
  794. LOOP    decrements CX and jumps if CX is not 0.  See JCXZ.
  795. LOOPE   dec's CX and jumps if CX is not 0 and zero flag is set
  796. LOOPZ   same as LOOPE
  797. LOOPNE  dec's CX and jumps if CX is not 0 and zero flag is clear
  798. LOOPNZ  same as LOOPNE
  799.  
  800. MOV     load  the destination  with  the contents of the source.  
  801.         Any  addressing mode may be used.  In addition,  segment 
  802.         registers may be used for pointer to register  MOV's  or 
  803.         register  to register - if one register is NOT a segment 
  804.         register.  Flags unchanged.  
  805.  
  806. MOVS    move  byte or word  string from the source pointed to by 
  807.         DS:SI (segment and offset) to destination pointed to  by 
  808.         ES:DI.  SI  and DI are incremented if the direction flag 
  809.         is clear (UP),  or decremented if it is set  (DN):  once 
  810.         for  MOVSB  or  twice for MOVSW.  Usually used with REP.  
  811.         Since moving a message line to the screen calls for  two 
  812.         increments to DI and MOV [DI],AX, but just one increment 
  813.         for SI and MOV AL,[SI] this block move cannot be used.  
  814.  
  815.  
  816.                                                O D I T S Z A P C
  817. MUL     multiply AL  by a single register or   x       . . . . x
  818.         byte  pointer, or  AX  by  a  double  
  819.         register  or word pointer.  Since AL 
  820.         or AX is implied by the op,  only one operand is needed.  
  821.         The result is found in AX or in AX  and  DX.  AH  or  DX 
  822.         will  be  cleared  by  the  operation and if no overflow 
  823.         occurs will remain at 0.  
  824.  
  825.                                                O D I T S Z A P C
  826. NEG     change a positive number to negative,  x       x x x x 1
  827.         or  a  negative  number  to positive.  
  828.         Takes one operand.  
  829.  
  830. NOP     no operation.  Takes one byte.  Can be used to make room 
  831.         in a program for possible changes during  debugging,  or 
  832.         to  remove  code temporarily that you wish to skip until 
  833.         debugging is finished.  
  834.  
  835. NOT     reverses each bit in operand. That is:
  836.  
  837.         if AL holds     0101 0011
  838.         NOT AL holds    1010 1100
  839.                                                O D I T S Z A P C
  840. OR      compare the bits of two operands. If   0       x x . x 0
  841.         a bit in the first operand is set to 
  842.         1,  OR  the  same  bit in the second 
  843.         operand is set to 1,  that bit in  the  result  (in  the 
  844.         first  operand) will be set to 1.  Only bits which are 0 
  845.         in both operands will be 0 in the result.  
  846.  
  847.         mov     ax,64h          ;0110 0100
  848.         or      ax,4Fh          ;0100 1111 
  849.                                 ;0110 1111    6Fh now in AX
  850.  
  851. OUT     output byte or word from AL or AX to one of 256 possible 
  852.         ports. Port number may be an immediate number or held in 
  853.         DX. That is:  OUT  DX,AL  or  OUT  61,AX.  
  854. POP     pop  word  off  stack  into  double register  (including 
  855.         segment registers)  or word pointer.
  856. POPF    pop  word  off stack into flags register.  All flags, of 
  857.         course, will be reset to value previously stored.
  858. PUSH    push  word  from  double  register   (including  segment 
  859.         register)  or word pointer onto stack.
  860. PUSHF   push flags onto stack.  Flags remain unchanged.
  861.  
  862. REP     repeat a string operation such as MOVSB,  until CX is 0.  
  863.         Decrements  CX.  Takes  no operand and affects no flags.  
  864.         REP must be on a line by itself.  
  865.  
  866.         rep movsw               ;WRONG. Movsw will be lost
  867.  
  868.         REP                     ;RIGHT
  869.         MOVSB
  870.  
  871. REPE    as for REP,  but will  end operation  if  zero  flag  is 
  872.         cleared;  for instance if 2 bytes being compared are not 
  873.         equal.  
  874. REPZ    same as REPE
  875. REPNE   as for REP,  but will end operation if zero flag is  set. 
  876. REPNZ   same as REPNE
  877. RET     causes  a  return  to  the  offset  address on the stack.  
  878.         Usually this address was placed there by a CALL.  
  879. RETF    Since a program that will be called from another program, 
  880.         such as one written in Basic,  needs a far return at  the 
  881.         end, RETF is recognized.  
  882.  
  883. The  next  six op codes each take two operands,  a register or a 
  884. pointer,  and 1 or CL.  1 indicates that the operation is to  be 
  885. performed  once;  CL holds the number of repeats.  In each case, 
  886. each bit in the  operand  is  moved  over  one  place  (for  one 
  887. operation) in the direction indicated, and the overflow bit goes 
  888. to the carry flag.  
  889.  
  890. For  a shift,  the empty bit is replaced with 0.  (But see SAR.) 
  891. For a rotate,  the empty bit is replaced  either  with  the  bit 
  892. shoved off the other end  (ROL, ROR)  or with the bit already in 
  893. the carry flag  (RCL,RCR).  
  894.                                                O D I T S Z A P C
  895. RCL     rotate left through carry flag.        x               x
  896. RCR     rotate right through carry flag.       x               x
  897. ROL     rotate left, bit 7 into bit 0          x               x
  898. ROR     rotate right, bit 0 into bit 7         x               x
  899. SHL     shift left, 0 into bit 0               x               x
  900. SHR     shift right, 0 into bit 7              x               x
  901. SAR     shift arithmetic right. The leftmost   x               x
  902.         bit  is  shifted with the others but  
  903.         is not replaced. It remains in bit 7, 
  904.         maintaining sign of number.  If enough SAR's  are  done, 
  905.         any  negative  number  will  become FFFF (or -1) and any 
  906.         positive number will become 0.  
  907.                                                O D I T S Z A P C
  908. SAHF    store contents of AH register in the           x x x x x
  909.         right  half of  flags register.  The
  910.         flags are stored as  S Z . A . P . C
  911.         with bits  1,  3,  and  5 unused and 
  912.         having no effect. See LAHF.  
  913. SBB     subtract with borrow.  Subtracts the   x       x x x x x
  914.         second   operand   from   the  first 
  915.         operand and also subtracts the 0  or 
  916.         1 that is in the carry flag 
  917. SUB     subtracts  as above, but ignores the   x       x x x x x
  918.         carry flag
  919. TEST    performs an  AND  operation  without   0       x x . x 0 
  920.         changing either operand. Can be used 
  921.         to compare for 2 numbers at the same 
  922.         time,  such  as 2 or 8 by TEST AL,0Ch.  If either number 
  923.         is found, the zero flag is set to 1 (non_zero). See CMP.  
  924. WAIT    wait while test pin not asserted.  No operand.
  925. XCHG    exchanges  the  two  operands.  One  operand  must be a 
  926.         register, the other may be a register or a pointer.  
  927. XLAT    adds the  contents of the AL register to the contents of 
  928.         the BX register and then moves the contents of the  byte 
  929.         pointed to by BX into the AL register.  
  930.  
  931.         that is,        mov     BX,Table    
  932.                         mov     AL,02
  933.                         XLAT
  934.  
  935.         performs like   mov     BX,Table
  936.                         mov     AX,02
  937.                         add     BX,AX
  938.                         mov     AL,[BX]      
  939.  
  940.         XLAT can be used to find one character in an array. When 
  941.         the character is found, BX will point to it in the table.  
  942.         For instance: 
  943.  
  944.                         mov     BX,Table-02
  945.         Table_Loop      mov     AL,02
  946.                         XLAT
  947.                         cmp     al,dl
  948.                         jz      Out_of_Loop     ;BX points to char
  949.                         loop    Table_Loop
  950.  
  951.                                                O D I T S Z A P C
  952. XOR     The exclusive OR.  Compares the bits   0       x x . x 0
  953.         of the two operands.  Similar to  OR 
  954.         except  that  a bit in the result is 
  955.         set  to  1 only if one but not both operand bits hold 1.  
  956.         If they match, both holding 1 (or 0, of course) that bit 
  957.         in the result is set to 0.  
  958.  
  959.         mov     ax,10h          ;0001 0000
  960.         xor     ax,10h          ;0001 0000 
  961.                                 ;0000 0000  0 now in AX
  962. but
  963.         mov     ax,40h          ;0100 0000
  964.         xor     ax,10h          ;0001 0000 
  965.                                 ;0101 0000  50h now in AX
  966.  
  967.                             Chapter VI
  968.                          Pseudo Op Codes
  969.         
  970.      There is also a group of operations which give instructions 
  971. to Lass but do not appear in the final object  code.  Hence  the 
  972. term  'pseudo'.  Some which are needed for .EXE assembly are not 
  973. needed  by Lass for .COM programs.  If they occur in your source 
  974. code they will simply be  ignored.  A  list  of  all  that  Lass 
  975. recognizes follows.  
  976.  
  977. Assume  ignored.  When a .COM  program  is loaded  by  DOS,  all 
  978.         segment  registers  are  set  to the same value.  If you 
  979.         change any of them within your program it is up  to  you 
  980.         to  keep  track  and  return them to the code segment as 
  981.         needed.  
  982.  
  983. DB      define byte.  This code  tells  Lass  to put one or more 
  984.         byte values into the object code.  If there are too many 
  985.         bytes in your series or string to fit on one source code 
  986.         line,  you must continue on the next line  with  another 
  987.         DB.  There  does  not have to be a label in front of DB.  
  988.         They may all be ascii  characters  inside  one  pair  of 
  989.         single quotes, forming a string, or they may be a series 
  990.         of  individual  numbers.  A  series  may  be  any mix of 
  991.         decimal,  hexadecimal  or  ascii  values,  separated  by 
  992.         commas.  Be  careful  not to use ' within a string.  The 
  993.         reverse quote, (`) may be used, or the double quote ("), 
  994.         but the normal single quote will terminate a string.  
  995.  
  996.         If the first operand is a number N and  it  is  followed 
  997.         not by a comma but by spaces and another number or ascii 
  998.         character in parentheses, a block of code will be filled 
  999.         with N characters. See examples below.  
  1000.  
  1001.         There are two limitations for a series: 
  1002.  
  1003.         If  the first operand is an ascii character,  it must be 
  1004.         just a single character.  Otherwise  the  line  will  be 
  1005.         translated  as  a  string.  Any  following  operand  may 
  1006.         include more than one character  between  pairs  of  ''.  
  1007.         There  must  be  no  space  between  a  number  and  its 
  1008.         following comma.  A vagrant space would  cause  Lass  to 
  1009.         think it had found the end of the line.  Examples: 
  1010.  
  1011. Series    DB   'A',65,49h,'AIA'
  1012. Just_One  DB   33h
  1013. Table     DB   1,2,3,   4,5    ;spaces AFTER a comma ok
  1014.           DB   235, 245, 255   ;255 is maximum for a byte
  1015. Filler    DB   10h (0)         ;fills 16 bytes with zeros
  1016.           DB   10h ('0')       ;now with 16 ascii zeros (30h)
  1017.           DB   10h ('ABC')     ;fills 48 bytes with ABCABC, etc.
  1018. Message_String:
  1019.           DB   'Any length to the end of the line is acc'
  1020.           DB   'epted. If the final apostrophe is not present'
  1021.           DB   ' the message will include   ;all else on line
  1022.  
  1023. DW      define  word.  Essentially the same as DB,  but no ascii 
  1024.         characters are accepted.  See  Filler  examples for  DB.  
  1025.         Examples for DW: 
  1026.  
  1027. Words   DW      4941h, 0,23     ;each number will fill 2 bytes
  1028. Filler  DW      10h (0)         ;fills 32d bytes with zeros
  1029.  
  1030.         Note that  Lass  does not care whether you have stored a 
  1031.         number as a byte or as a word,  and will not warn you if 
  1032.         you remove a word where you stored a byte or vice versa.  
  1033.  
  1034. END     ignored
  1035.  
  1036. EQU     sets a value to a label.  The label  must be present and
  1037.         on  the  same  line.  The  value must be no greater than 
  1038.         65,535 (FFFFh) so it  can  be  contained  in  one  word.  
  1039.         Examples: 
  1040.  
  1041. SCREEN     equ  0B800h                  ;one word
  1042. Keyboard_Call   equ     21h             ;one byte
  1043. Big_Letter      equ     'A'
  1044. Letter_Plus     equ     Big_Letter+20h
  1045.  
  1046.         but the following are NOT acceptable:
  1047.  
  1048. Keyboard_Call:
  1049.         equ     21h             ;label must be on same line
  1050. Value   equ     70000h          ;too large for one word
  1051.  
  1052.         In  addition,  it is recommended that all EQU statements 
  1053.         be placed at the beginning of the program, or errors may 
  1054.         result.  See LABEL  discussion  for  a  fierce  warning.  
  1055.         Data is often placed with the EQU statements,  to form a 
  1056.         reference block where it easy to  find.  This  causes  a 
  1057.         small conflict since the first code byte must also be at 
  1058.         the  beginning  of  the program.  No real problem,  just 
  1059.         start the program with a  jump  over  the  data  to  the 
  1060.         beginning of the code. For instance: 
  1061.  
  1062.         JMP     Work_Starts     ;your program code
  1063.  
  1064. Name    equ     5               ;place all EQU statements first
  1065. Height  equ     10
  1066. Varbl_1 db      0               ;now your data block
  1067. Table   db      0,1,2,3         ;etc., etc., etc.
  1068.  
  1069. Work_Starts:
  1070.         push    DS              ;and so forth
  1071.  
  1072. ORG     origin.  Forces the  next  code byte to be at the offset 
  1073.         address given in the one operand.  All bytes between the 
  1074.         current object code byte and the  origin  byte  will  be 
  1075.         filled  with  zeros.  If  there  are too many code bytes 
  1076.         already assembled,  Lass will tell you so you can revise 
  1077.         the origin address.  
  1078.  
  1079. PROC    ignored
  1080. 
  1081.  
  1082.  
  1083.